const tool = require('../tools/tool')

module.exports = {
    initChatRoom: {
        exp: '初始化聊天室',
        method: 'post',
        auth: true,
        async func(data) {
            let userId = data?.currentUser?.id
            if (!userId) throw '用户不存在，聊天室初始化失败'
            return tool.methods.chat().getUserChatRoom(userId)
        }
    },
    getStatus: {
        exp: '获取用户聊天室状态',
        method: 'post',
        auth: true,
        async func(data) {
            let userId = data?.currentUser?.id
            if (!userId) throw '用户不存在'
            return await tool.methods.chat().getStatus(userId)
        }
    },
    historyMessage: {
        exp: '获取聊天历史消息',
        method: 'post',
        auth: true,
        async func(data) {
            let userId = data?.currentUser?.id
            if (!userId) throw '用户不存在'
            return await tool.methods.chat().getChatMessage(userId, data.param.finalId)
        }
    },
    message: {
        exp: '发送聊天消息',
        method: 'post',
        noQueue: true,
        auth: true,
        async func(data, headers, req) {
            let userId = data?.currentUser?.id
            if (!userId) throw '用户不存在'
            let input = data.param.input
            // let status = data.param.status
            await tool.methods.chat().addMessage(
                userId,
                1,
                1,
                input
            )
            let aire = await tool.openai.send(`用户现在发来：${input} AI（你）和用户的聊天历史记录：${await tool.methods.chat().getChatHistoryString(userId)} 全部考试题：${tool.methods.question().allQuestionString._str}`)
            return await tool.methods.chat().addMessage(
                userId,
                1,
                -1,
                aire
            )
            //             // 当前状态为没有考试缓存的状态 以及 有考试缓存但是没有正在进行的考试和强化训练的状态
            //             if (status === 0 || status === 4) {
            //                 let categoryStr = await tool.methods.category().getAllCategoriesString()
            //                 let ai_answer = await tool.openai.send(`用户输入了一段文本：${input}。

            // 请你判断用户是否是在寻求做题练习：

            // 1. 如果用户明确表示“想做题”或“请求某类题目”，请你分析其意图，并在下方提供的题目类别列表中查找匹配项。

            //    ⚠️ **注意：只能使用以下列表中存在的类别ID，其他类别一律不允许返回！**

            //    - 如果存在匹配类别，请返回 JSON（仅包含以下字段）：
            //      {
            //        "categoryId": [匹配的类别 ID]
            //      }

            //    - 如果用户想做的题目类别不在列表中，请返回：
            //      {
            //        "message": "您想做的此类题目题库中还没有题目，敬请期待！"
            //      }

            // 2. 如果用户没有明确表达要做题，请你作为 AI 自主思考并直接回答用户问题，但是不能给用户出题，返回格式如下：
            //    {
            //      "message": "[你的回答内容]"
            //    }

            // 题目类别列表如下：${categoryStr}
            // `)
            //                 try {
            //                     ai_answer = tool.extractJsonFromString(ai_answer)
            //                     if (ai_answer === null) throw 'JSON解析失败'
            //                 } catch (error) {
            //                     console.log(error)
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 ai_answer
            //                             )
            //                         ]
            //                     }
            //                 }
            //                 if (ai_answer.categoryId === undefined) {
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 ai_answer.message
            //                             )
            //                         ]
            //                     }
            //                 } else {
            //                     let categoryInfo = await tool.methods.category().getSingle(ai_answer.categoryId)
            //                     if (!categoryInfo) {
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     `我暂时不能理解您的意思，请再说一遍。`
            //                                 )
            //                             ]
            //                         }
            //                     }
            //                     // 开始随机选择试题
            //                     let randomPaperId = await tool.methods.paper().getRandomPaperIdByCategoryId(userId, categoryInfo.id)
            //                     // 加入考试缓存
            //                     await tool.methods.exam().addCache({
            //                         userId,
            //                         categoryId: categoryInfo.id,
            //                         paperId: randomPaperId
            //                     })
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 `好的，我们接下来开始进行 ${categoryInfo.name} 考试。`
            //                             ),
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 2,
            //                                 -1,
            //                                 '',
            //                                 categoryInfo.id,
            //                                 randomPaperId,
            //                                 (await tool.methods.question().getFirstQuestion(randomPaperId)).id
            //                             ),
            //                         ],
            //                         changeStatus: true
            //                     }
            //                 }
            //             }
            //             // 当前正在考试 或者 当前正在进行强化训练
            //             if (status === 1 || status === 3) {
            //                 // 正在进行的考试的试卷ID
            //                 let currentDoingQuestion = await tool.methods.question().getCurrentUserDoQuestion(userId)
            //                 let currentQuestionScore = 0
            //                 let examOrReDoCacheId = await (async () => {
            //                     if (status === 1) return (await tool.methods.exam().getLatestOneCache(userId)).id
            //                     return (await tool.methods.exam().getLatestOneReDoCache(userId)).id
            //                 })()
            //                 let message = ''
            //                 if (currentDoingQuestion.type === '选择') {
            //                     let ai_answer = await (async () => {
            //                         if (status === 1) {
            //                             return await tool.openai.send(
            //                                 `用户发来选${input}，请你判断一下，用户发来的内容中是否包含有选择题的答案选项字母，如果有的话，请提取出答案，全部大写，除了答案选项字母之外不能有任何的字符，也就是说你返回给我的内容是一个JSON（除了JSON本身之外两端不能包含其他任何字符），JSON只有字段叫options，options的值为正则表达式/[ABCD]{0,4}/g检验过的的内容。如果用户发来的内容不存在任何的答案选项或者用户发来的内容中有其他选项答案（除了ABCD之外的选项），你就给我回复一个意思为请输入你的答案选项的句子保存在JSON（除了JSON本身之外两端不能包含其他任何字符）的message字段中，除了上面两种情况之外不能回复其他任何句子。如果用户想主动问你某个题的答案是什么，你就回复一个JSON，message字段的值为“请输入答案”，千万不要主动帮用户答题。`
            //                             )
            //                         }
            //                         return await tool.openai.send(
            //                             `用户发来选${input}，请你判断一下，用户发来的内容是否是想回答题目的答案的意思，例如“我选【某选项】、选【某选项】”，如果是的话，请提取出用户想要回答的答案，全部大写，除了答案选项字母之外不能有任何的字符，也就是说你返回给我的内容是一个JSON（除了JSON本身之外两端不能包含其他任何字符），JSON只有字段叫options，options的值为正则表达式/[ABCD]{0,4}/g检验过的的内容，同时还要有一个message字段，这个字段对用户选择的答案进行分析，错的话直接给出正确答案选项和解析。如果用户说的是其他的和上面的无关的内容，可以对他进行回复。下面是你和用户前面的几条聊天记录，从上到下时间从早到晚，如果用户想要问上一个题的相关问题，你可以在聊天记录中找之前的内容：${await tool.methods.chat().changeMessageArrToString(await tool.methods.chat().getLastChatMessages(userId, 12))}。`
            //                         )
            //                     })()
            //                     try {
            //                         ai_answer = tool.extractJsonFromString(ai_answer)
            //                         if (ai_answer === null) throw 'JSON解析失败'
            //                     } catch (error) {
            //                         console.log(error)
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     '我不能理解您的意思，请将您的答案再输入一次。'
            //                                 )
            //                             ]
            //                         }
            //                     }
            //                     if (!ai_answer.options) {
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     ai_answer.message
            //                                 )
            //                             ]
            //                         }
            //                     } else {
            //                         message = ai_answer.message
            //                         if (/[ABCD]{1,4}/g.test(ai_answer.options)) {
            //                             currentQuestionScore = await tool.computeNotEassyQuestionScore(currentDoingQuestion.id, ai_answer.options)
            //                             await tool.methods.exam().updateQuestionCache.add({
            //                                 questionId: currentDoingQuestion.id,
            //                                 userAnswer: await tool.getAnswerObject(currentDoingQuestion.id, ai_answer.options),
            //                                 isReDo: status === 3,
            //                                 examOrReDoCacheId,
            //                                 score: currentQuestionScore
            //                             })
            //                         } else {
            //                             return {
            //                                 arr: [
            //                                     await tool.methods.chat().addMessage(
            //                                         userId,
            //                                         1,
            //                                         -1,
            //                                         '请检查然后重新输入。'
            //                                     )
            //                                 ]
            //                             }
            //                         }
            //                     }
            //                 } else {
            //                     let essayScore = await tool.computeEssayQuestionScore((await tool.methods.exam().getLatestOneQuestionCache(status === 3, examOrReDoCacheId)))
            //                     if (isNaN(essayScore)) {
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     '请检查然后重新输入。'
            //                                 )
            //                             ]
            //                         }
            //                     } else {
            //                         await tool.methods.exam().updateQuestionCache.add({
            //                             questionId: currentDoingQuestion.id,
            //                             userAnswer: {
            //                                 text: input
            //                             },
            //                             isReDo: status === 3,
            //                             examOrReDoCacheId,
            //                             score: essayScore
            //                         })
            //                     }
            //                 }

            //                 // 判断是否为最后一题
            //                 let examCache = await tool.methods.exam().getLatestOneCache(userId)
            //                 if (await (async () => {
            //                     if (status === 1) {
            //                         return await tool.methods.paper().isLastQuestion(currentDoingQuestion.paperId, currentDoingQuestion.id)
            //                     } else {
            //                         let reDoCount = (await tool.methods.exam().getReDoById(examCache.reDoCaches[0].id)).reDoQuestionMaxCount
            //                         let currentReDoCount = (await tool.methods.exam().getReDoById(examCache.reDoCaches[0].id)).reDoQuestionCount
            //                         if (currentReDoCount === reDoCount) return true
            //                         return false
            //                     }
            //                 })()) {
            //                     // 是最后一题，计算成绩
            //                     if (status === 1) {
            //                         let score = await (async () => {
            //                             let doneQuestions = await tool.methods.exam().computeScore(false, examOrReDoCacheId)
            //                             let score = 0
            //                             for (let i = 0; i < doneQuestions.length; i++) {
            //                                 score += doneQuestions[i].score
            //                             }
            //                             score /= (await tool.methods.paper().getQuestionNum(currentDoingQuestion.paperId))
            //                             return score
            //                         })()
            //                         await tool.methods.exam().updateCache.score(examCache.id, score)
            //                         let examCache2 = await tool.methods.exam().getById(examCache.id)
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     message
            //                                 ),
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     `考试已完成，时长${(() => {
            //                                         let c = (new Date(new Date(examCache2.endAt) - new Date(examCache2.startAt))).getTime()
            //                                         c = parseInt(c / 1000)
            //                                         if (c < 60) {
            //                                             return `${c}秒`
            //                                         }
            //                                         return `${parseInt(c / 60)}分${c % 60}秒`
            //                                     })()}，您的分数：${score}，${score >= (await tool.methods.settings().getItem('passScore')) ? '恭喜您通过了本次考试。' : '很遗憾未通过考试。我可以帮您分析上次的错题，也可以安排针对性的强化训练。完成训练并达到及格标准后，您就可以继续挑战下一套试题啦！'}`
            //                                 )
            //                             ],
            //                             changeStatus: true,
            //                             updateTimer: 0
            //                         }
            //                     } else {
            //                         let score = await (async () => {
            //                             let doneQuestions = await tool.methods.exam().computeScore(true, examCache.reDoCaches[0].id)
            //                             let score = 0
            //                             for (let i = 0; i < doneQuestions.length; i++) {
            //                                 score += doneQuestions[i].score
            //                             }
            //                             score /= (await (async () => {
            //                                 return (await tool.methods.exam().getLatestOneReDoCache(userId)).reDoQuestionMaxCount
            //                             })())
            //                             return score
            //                         })()
            //                         await tool.methods.exam().updateReDoCache.score(examCache.reDoCaches[0].id, score)
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     message
            //                                 ),
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     `强化训练已完成，您的分数：${score}，${score >= (await tool.methods.settings().getItem('passScore')) ? '恭喜您通过了本次强化训练。' : '很遗憾未通过强化训练。我可以帮您分析上次的错题，也可以安排针对性的强化训练。完成训练并达到及格标准后，您就可以继续挑战下一套试题啦！'}`
            //                                 )
            //                             ],
            //                             changeStatus: true
            //                         }
            //                     }
            //                 } else {
            //                     // 不是最后一题，发送下一题，更新考试时间（如果是考试的话）
            //                     if (status === 1) {
            //                         let questionNum = await tool.methods.paper().getQuestionNum(examCache.paperId)
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     message
            //                                 ),
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     2,
            //                                     -1,
            //                                     `共${questionNum}题，已完成${currentDoingQuestion.index}题，当前进度${parseInt((currentDoingQuestion.index - 1) / questionNum * 10000) / 100}%。`,
            //                                     currentDoingQuestion.categoryId,
            //                                     currentDoingQuestion.paperId,
            //                                     (await tool.methods.question().getCurrentUserDoQuestion(userId)).id
            //                                 )
            //                             ],
            //                             updateTimer: await (async () => {
            //                                 let lastUserExamCache = await tool.methods.exam().getLatestOneCache(userId)
            //                                 return parseInt(((new Date((new Date(lastUserExamCache.startAt)).getTime() + lastUserExamCache.paperInfo.duration * 60 * 1000)).getTime() - (new Date()).getTime() - 10000) / 1000)
            //                             })()
            //                         }
            //                     } else {
            //                         let reDoCache = await tool.methods.exam().getLatestOneReDoCache(userId)
            //                         return {
            //                             arr: [
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     1,
            //                                     -1,
            //                                     message
            //                                 ),
            //                                 await tool.methods.chat().addMessage(
            //                                     userId,
            //                                     2,
            //                                     -1,
            //                                     `共${reDoCache.reDoQuestionMaxCount}题，已完成${reDoCache.reDoQuestionCount}题，当前进度${parseInt(reDoCache.reDoQuestionCount / reDoCache.reDoQuestionMaxCount * 10000) / 100}%。`,
            //                                     currentDoingQuestion.categoryId,
            //                                     currentDoingQuestion.paperId,
            //                                     (await tool.methods.exam().reDoGetNextQuestion(userId)).id
            //                                 )
            //                             ]
            //                         }
            //                     }
            //                 }
            //             }
            //             // 当前已做完考试或者强化训练，但是不及格
            //             if (status === 2) {
            //                 let lastWrongQuestionsStr = tool.methods.exam().changeQuestionCachesToString(await tool.methods.exam().getLastExamOrReDoWrongQuestions(userId))
            //                 let ai_answer = await tool.openai.send(`用户发来：${input}，如果用户的意思是想进行强化训练，请你回复一个JSON（除了JSON之外两端不能有其他字符），有一个startReDo: true字段，如果用户想要进行强化训练，务必要有这个字段。如果用户想对错题进行分析，请你根据用户发来的问题和下面用户上次做过的错题进行回复即可，回复的内容和用户的问题相关，回复的内容为一个字符串文本，字符串文本存到JSON中，JSON（除了JSON之外两端不能有其他字符），也就是说必须要返回一个包含message字符串的JSON数据，内容存到message字段中，内容的最后可以再提示一下现在可以帮你分析错题或者开始强化训练。如果用户发来想要做某类别的考试题，你就说类似“上次考试未及格，需要进行强化训练的提示”，也是存到message中，内容的最后可以再提示一下现在可以帮你分析错题或者开始强化训练。如果用户问的是其他和开始强化训练以及分析上次错题无关的内容，请你随便回复一个问候语形式的内容，内容的最后可以再提示一下现在可以帮你分析错题或者开始强化训练，返回一个JSON（除了JSON之外两端不能有其他字符），内容存到message字段中。如果用户的意思是想进行强化训练，请你回复一个JSON（除了JSON之外两端不能有其他字符），有一个startReDo: true字段，如果用户想要进行强化训练，务必要有这个字段。如果用户发来想要看一下原题，你就回复一个JSON，有一个showQuestion字段，值为用户想看的错题的ID。用户上次出现的错题：${lastWrongQuestionsStr}`)
            //                 try {
            //                     ai_answer = tool.extractJsonFromString(ai_answer)
            //                     if (ai_answer === null) throw 'JSON解析失败'
            //                 } catch (error) {
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 '请检查然后重新输入。'
            //                             )
            //                         ]
            //                     }
            //                 }
            //                 if (ai_answer.startReDo) {
            //                     let examCache = await tool.methods.exam().getLatestOneCache(userId)
            //                     await tool.methods.exam().updateCache.addReDoCount(examCache.id, tool.methods.exam().selectQuestionCacheKeywords(await tool.methods.exam().getLastExamOrReDoWrongQuestions(userId)).join(','))
            //                     let nextQuestion = await tool.methods.exam().reDoGetNextQuestion(userId)
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 '开始强化训练。'
            //                             ),
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 2,
            //                                 -1,
            //                                 '',
            //                                 nextQuestion.categoryId,
            //                                 nextQuestion.paperId,
            //                                 nextQuestion.id
            //                             ),
            //                         ],
            //                         changeStatus: true
            //                     }
            //                 } else {
            //                     if (ai_answer.showQuestion) {
            //                         let questionInfo = await tool.methods.question().getSingle(ai_answer.showQuestion)
            //                         if (questionInfo) {
            //                             return {
            //                                 arr: [
            //                                     await tool.methods.chat().addMessage(
            //                                         userId,
            //                                         2,
            //                                         -1,
            //                                         '',
            //                                         questionInfo.categoryId,
            //                                         questionInfo.paperId,
            //                                         questionInfo.id
            //                                     )
            //                                 ]
            //                             }
            //                         } else {
            //                             return {
            //                                 arr: [
            //                                     await tool.methods.chat().addMessage(
            //                                         userId,
            //                                         1,
            //                                         -1,
            //                                         '请重新输入问题。'
            //                                     )
            //                                 ]
            //                             }
            //                         }
            //                     }
            //                     return {
            //                         arr: [
            //                             await tool.methods.chat().addMessage(
            //                                 userId,
            //                                 1,
            //                                 -1,
            //                                 ai_answer.message
            //                             )
            //                         ]
            //                     }
            //                 }
            //             }
        }
    }
}